/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package Logica;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Scanner;

/**
 * La clase Arbol implementa los metodos de la estructura del diccionario
 *
 * @author ricardogarcia
 */
public class Arbol {

    private Node root;
    private Node posicion;

    /**
     * Constructor de la clase Arbol por defecto
     */
    public Arbol() {
        root = null;

    }

    /**
     * Constructor de la clase que asigna una raiz
     *
     * @param root de tipo {
     * @Node}
     */
    public Arbol(Node root) {
        this.root = root;
    }

    /**
     * Inserta una nueva palabra al arbol
     *
     * @param palabra de tipo {@String}. Es la palabra que se desea 
     * insertar en el diccionario
     */
    public void insertar(String palabra) {


        int indice = 0;

        if (root == null) {
            root = new Node(' ');
        }

        Node temp = root;


        while (indice < palabra.length()) {

            if (temp.getListaletras().size() == 0) {
                Node nuevo = new Node(palabra.charAt(indice));
                temp.listaletras.add(nuevo);
                temp = nuevo;
            } else {
                boolean encontrado = false;
                Iterator r = temp.getListaletras().iterator();

                int i = 0;

                while (!encontrado && i < temp.getListaletras().size()) {
                    Node nodo = (Node) r.next();
                    if (nodo.getLetra() == palabra.charAt(indice)) {

                        temp = nodo;
                        encontrado = true;
                    }
                    r.hasNext();
                    i++;
                }

                if (!encontrado) {

                    Node nuevo = new Node(palabra.charAt(indice));
                    temp.listaletras.add(nuevo);
                    temp = nuevo;
                }

            }
            indice++;

        }
        temp.esFinalPalabra = true;
    }

    /**
     * Lectura del archivo que contiene las palabras del diccionario
     *
     * @param Archivo de tipo {
     * @String}. ES el nombre del archivo que contiene las palabras del
     * diccionario.
     */
    public void LeerArchivo(String Archivo) {


        try {
            Scanner input = new Scanner(new File(Archivo));

            while (input.hasNextLine()) {
                String palabra = input.nextLine();
                insertar(palabra);
            }
        } catch (Exception e) {

            e.printStackTrace();
            return;
        }
    }

    /**
     * Busca una palabra dentro del arbol
     *
     * @param palabra de tipo {
     * @String}. Es la palabra que se desea buscar dentro del diccionario
     * @return encontrado de tipo {
     * @boolean}. Responde si la palabra a buscar existe en el diccionario o no.
     */
    public boolean buscarPalabra(String palabra) {

        boolean encontrado = false;
        Node temp = root;

        if (root == null) {
            return false;
        } else {

            for (int i = 0; i < palabra.length(); i++) {


                if (!temp.getListaletras().isEmpty()) {
                    Iterator r = temp.getListaletras().iterator();
                    encontrado = false;
                    while (!encontrado && r.hasNext()) {

                        Node nodo = (Node) r.next();

                        if (nodo.getLetra() == palabra.charAt(i)) {

                            temp = nodo;
                            encontrado = true;
                        }
                    }
                } else {
                    return false;
                }
            }
        }

        if (encontrado) {
            posicion = temp;
            return true;
        } else {
            return false;
        }
    }

    /**
     * Verifica que la palabra exista en el diccionario y sea valida.
     *
     * @param str de tipo String. Es la palabra a evaluar.
     * @return boolean. Responde si la palabra es valida o no.
     */
    public boolean buscar(String str) {
        if (buscarPalabra(str) && posicion.esFinalPalabra) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * Imprime el arbol de palabras.
     */
    void imprimir() {

        Node t = root;
        System.out.println(root.getLetra());
        Iterator r = root.getListaletras().iterator();
        for (int i = 0; i < root.getListaletras().size(); i++) {

            Node nodo = (Node) r.next();
            System.out.println(nodo.getLetra());
            r.hasNext();

        }
    }
}
